import random
import re
import string

from .print import *
from .load_and_write import *

def do_convert_str_to_float_list(str_list: str):
    """
    将字符串转换为float列表
    :param str_list:
    :return:
    """
    import ast
    # 使用ast.literal_eval将字符串转换为Python列表
    list_obj = ast.literal_eval(str_list)
    return list_obj


def do_split_list(source_list, num_subsets):
    """
    最后一个块包含多余的余数
    :param source_list:
    :param num_subsets:
    :return:
    """
    keys_per_subset = len(source_list) // num_subsets
    # 初始化子集字典列表
    subsets = []
    # 分割字典
    for i in range(num_subsets):
        # 计算当前子集的起始和结束索引
        start_index = i * keys_per_subset
        end_index = (i + 1) * keys_per_subset if i < num_subsets - 1 else None
        subset_list = source_list[start_index:end_index]
        subsets.append(subset_list)
    return subsets

def do_split_txt2asr_tag(text):
    """
    input "hello ,how are you?<HAPPY>"
    output ('hello ,how are you?' <HAPPY>)
    input: "你好呀，威风威风是否是<NAME><HYPPY>"
    output: ('你好呀，威风威风是否是<NAME>', '<HYPPY>')
    必须是str+<标签>的形式
    Args:
        text:

    Returns:

    """
    # 使用正则表达式匹配标签
    match = re.match(r'^(.*?)(<[^>]+>)$', text)

    # 如果匹配到一个标签
    if match:
        return match.group(1), match.group(2)
    else:
        return None, None


def do_split_txt2tag_str(text):
    """
    input "<HAPPY>hello ,how are you?"
    output ('<HAPPY>', 'hello ,how are you?')
    input: "<NAME><HYPPY>你好呀，威风威风是否是"
    output: ('<NAME>', '<HYPPY>你好呀，威风威风是否是')

    只提取开头的第一个标签，剩余内容（包括其他标签和文本）作为第二部分
    Args:
        text: 带标签的文本，标签在开头

    Returns:
        元组 (第一个标签, 剩余内容)，如果没有标签则返回 (None, None)
    """
    # 正则表达式匹配第一个<...>形式的标签
    match = re.match(r'^(<[^>]+>)(.*)$', text)

    if match:
        # 第一个分组是第一个标签，第二个分组是剩余的所有内容
        return match.group(1), match.group(2)
    else:
        return None, None


def do_clean_text(text, en_lower=False):
    """
    清理文本
    删除汉字左右两侧的空格
    将英文转成小写(可选)
    删除 < 和 > 符号两侧的空格
    在汉字与英文字母之间添加空格
    :param text:
    :param en_lower:
    :return:
    """
    # 1. 删除每个汉字左右两侧的空格
    text = re.sub(r'\s*([\u4e00-\u9fff])\s*', r'\1', text)

    # 2. 在汉字和字母之间添加空格
    text = re.sub(r'([\u4e00-\u9fff])([a-zA-Z])', r'\1 \2', text)  # 汉字后加空格
    text = re.sub(r'([a-zA-Z])([\u4e00-\u9fff])', r'\1 \2', text)  # 英文字母后加空格

    # 3. 将英文转成小写
    if en_lower:
        text = text.lower()

    # 4. 删除 < 和 > 符号两侧的空格
    text = re.sub(r'\s*<\s*', '<', text)
    text = re.sub(r'\s*>\s*', '>', text)

    return text


def do_judge_has_no_chinese(s):
    """
    判断字符串是否完全不含有中文

    参数:
        s: 待检查的字符串

    返回:
        True: 完全不含中文
        False: 含有中文
    """
    # 匹配中文的正则表达式（包括基本汉字和常见中文符号）
    chinese_pattern = re.compile(
        r'[\u4e00-\u9fa5\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b]')
    # 检查是否有匹配的中文
    return not bool(chinese_pattern.search(s))



def do_replace_str_to_file(source_str, target_str, input_file, output_file):
    """
    将 input_file 文件中的所有 source_str 替换为 target_str，并将结果写入 output_file。

    :param source_str: 要被替换的字符串
    :param target_str: 用于替换的目标字符串
    :param input_file: 源文件路径
    :param output_file: 输出文件路径
    :return: None
    """
    try:
        # 读取输入文件内容
        with open(input_file, 'r', encoding='utf-8') as f:
            content = f.read()

        # 替换指定字符串
        updated_content = content.replace(source_str, target_str)

        # 将替换后的内容写入输出文件
        with open(output_file, 'w', encoding='utf-8') as f:
            f.write(updated_content)

        print_info(f"替换完成，结果已保存到 {output_file}")

    except FileNotFoundError:
        print_error(f"错误: 输入文件 '{input_file}' 未找到")
    except IOError as e:
        print_error(f"IO 错误: {e}")
    except Exception as e:
        print_error(f"发生了未知错误: {e}")


import os
from typing import Union, Dict, List, Optional

import os
from typing import Union, Dict, List, Optional


def do_find_files_from_dir(
        dir_path: str,
        suffix: str,
        if_recursive: bool = True,
        return_pattern: str = "scp",
        output_file_path: Optional[str] = None
) -> Union[Dict[str, str], List[str], None]:
    """
    从指定目录中查找指定后缀的文件，并根据参数返回不同格式的结果或写入文件

    :param dir_path: 要查找的目录路径
    :param suffix: 要查找的文件后缀，如".txt"、"py"（带不带点均可）
    :param if_recursive: 是否递归查找，True表示递归查找子目录，False表示只查找当前目录
    :param return_pattern: 返回格式，"scp"表示返回字典（key为无后缀文件名，value为绝对路径），"list"表示返回绝对路径列表
    :param output_file_path: 输出文件路径，如果不为None则将结果写入该文件，否则返回结果
    :return: 根据return_pattern返回字典或列表，若指定了output_file_path则返回None
    :raises ValueError: 当return_pattern不是"scp"或"list"时抛出
    :raises NotADirectoryError: 当dir_path不是有效目录时抛出
    """

    # 内部函数：将字典写入文件
    def write_dict_to_scp(data: Dict[str, str], file_path: str) -> None:
        with open(file_path, 'w', encoding='utf-8') as f:
            for name, path in data.items():
                f.write(f"{name}: {path}\n")

    # 内部函数：将列表写入文件
    def write_list_to_file(data: List[str], file_path: str) -> None:
        with open(file_path, 'w', encoding='utf-8') as f:
            for item in data:
                f.write(f"{item}\n")

    # 验证目录是否存在
    if not os.path.isdir(dir_path):
        raise NotADirectoryError(f"目录不存在或不是有效目录: {dir_path}")

    # 验证返回模式是否有效
    if return_pattern not in ("scp", "list"):
        raise ValueError(f"return_pattern必须是'scp'或'list'，实际为: {return_pattern}")

    # 统一处理后缀格式，确保以点开头
    normalized_suffix = suffix if suffix.startswith('.') else f'.{suffix}'

    # 初始化结果容器
    file_dict: Dict[str, str] = {}
    file_list: List[str] = []

    # 遍历目录
    for root, _, files in os.walk(dir_path):
        for file in files:
            # 检查文件后缀是否匹配（不区分大小写）
            if file.lower().endswith(normalized_suffix.lower()):
                # 获取文件绝对路径
                file_abs_path = os.path.abspath(os.path.join(root, file))
                # 获取无后缀的文件名（包含原始文件名，去除查找用的后缀）
                file_name_without_ext = os.path.splitext(file)[0]

                # 添加到结果容器
                file_list.append(file_abs_path)
                # 处理可能的文件名重复（保留最后找到的文件路径）
                file_dict[file_name_without_ext] = file_abs_path

        # 如果不递归，只处理当前目录就退出
        if not if_recursive:
            break

    # 输出结果或写入文件
    if output_file_path is not None:
        # 写入文件
        if return_pattern == "scp":
            write_dict_to_scp(file_dict, output_file_path)
        else:  # return_pattern == "list"
            write_list_to_file(file_list, output_file_path)
        return None
    else:
        # 返回结果
        if return_pattern == "scp":
            return file_dict
        else:  # return_pattern == "list"
            return file_list


def do_get_random_str(length: int = 10):
    """
    获取指定长度的随机字符串
    :param length: 字符串长度
    :return: 随机字符串
    """
    return ''.join(random.sample(string.ascii_letters + string.digits, length))

def do_get_random_str_only_digits(length: int = 10):
    """
    获取指定长度的随机数字字符串
    :param length:
    :return:
    """
    return ''.join(random.sample(string.digits, length))

def do_get_random_str_only_letters(length: int = 10):
    """
    获取指定长度的随机字母字符串
    :param length:
    :return:
    """
    return ''.join(random.sample(string.ascii_letters, length))


def do_get_fake_file_path():
    """
    获取一个临时文件路径
    :return:
    """
    file_name_random_str =   do_get_random_str(10)
    return f'~/.cache/{file_name_random_str}.txt'